package com.pai4j.search.service.voctor;


import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.ArrayBlockingQueue;


@Slf4j
public abstract class AbstractMilvusQueueService<T, R, D> extends AbstractMilvusService<T, R> {

    /**
     * 队列消费失败，最大重试3次
     */
    private static final int RETRY_TIMES = 3;

    /**
     * 由具体的实现类返回
     *
     * @return
     */
    protected abstract ArrayBlockingQueue<D> queue();

    /**
     * 采用队列模式消费
     *
     * @return
     */
    @Override
    protected boolean queueModel() {return true;}

    /**
     * 如果走队列实现方式，可以再次重新数据写入的方法
     *
     * @param data
     * @return
     */
    public abstract boolean doWriteCollection(D data);

    @Override
    public boolean writeCollection(T data) {

        return true;
    }

    /**
     * 重新加入队列
     *
     * @param task
     */
    protected void putTaskQueue(D task) {
        int retryTimes = 0;
        while (retryTimes <= RETRY_TIMES) {
            try {
                queue().put(task);
                return;
            } catch (InterruptedException e) {
                retryTimes ++;
            }
        }
    }

    public void consumeTask() {
        while (true) {
            D task = null;
            try {
                task = queue().take();
                Thread.sleep(1000);
                if (task != null) {
                    // 处理任务
                    this.doWriteCollection(task);
                }
            } catch (Exception e) {
                // TODO
                this.putTaskQueue(task);
            }
        }
    }
}
